Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@editor/app/`(dev)/ui/components/tree-view/_custom-source.tsx:
- Around line 81-83: getRoot currently returns the hardcoded string "doc", which
breaks adapters created with non-"doc" roots; change getRoot() in the class that
extends JsonSource to return the instance's configured root (the
constructor-provided root property—e.g., use the class field that stores the
JsonSource root such as this.root or this.source.root) instead of the literal
"doc", optionally falling back to "doc" only if the instance root is undefined.

In `@editor/app/`(dev)/ui/components/tree-view/_fixtures.ts:
- Around line 775-784: The fixture's total count is underreporting because each
group contributes depth chain nodes plus one group row; update the returned
total in the fixture (the object that sets source: new InMemoryTreeSource(...),
expanded, maxDepth: depth) to account for the group row (for example compute
total as groups * (depth + 1) or otherwise sum group rows plus chain nodes) so
the demo reports the correct visible row count.
- Around line 722-752: The buildDeepFixture function currently builds chainIds
with for (let d = 0; d < depth; d++) which allows depth <= 0 to produce an empty
chain and then uses chainIds[chainIds.length - 1]! causing undefined node ids;
add an input guard at the start of buildDeepFixture to validate and coerce/throw
for invalid opts.depth and opts.groups (e.g., ensure depth >= 1 and groups >= 1)
or default them to safe minimums, and then proceed to build chainIds and push
nodes (references: buildDeepFixture, chainIds, depth, groups, nodes.push) so no
empty arrays are accessed at chainIds[chainIds.length - 1].

In `@editor/app/`(dev)/ui/components/tree-view/_panel.tsx:
- Around line 291-339: The drag handlers currently process any pointer's events
once a drag has started; restrict updates and commit to the initiating pointer
only by checking pointerId. In onMove (function onMove) after determining the
active drag handle (dragRef.current) compare e.pointerId to the initiating
pointer id (store the initiating id when creating the drag from
pendingRef.current.pointerId or set a dedicated activePointerId on
dragRef/current state) and return if they differ before updating lastPointerRef,
calling handle.over, or kicking auto-scroll. Similarly change onUp to accept the
PointerEvent and only call controller.commitDrag() / clear
dragRef.pendingRef.lastPointerRef when e.pointerId matches the initiating
pointer id; ensure you clear the stored initiating pointer id when the drag
ends.

In `@editor/app/`(dev)/ui/components/tree-view/_recipes.tsx:
- Around line 184-192: The onKeyDown handler calls onCancel() when Escape but
the onBlur handler still calls onCommit(value.trim() || initial), so Escape can
be followed by a blur commit; fix by introducing a short-lived flag (e.g.,
ignoreBlurRef or canceledRef) used by the onKeyDown Escape branch to set true
and by onBlur to skip calling onCommit if the flag is set, then reset the flag
(false) after ignoring the blur; update the handlers around onKeyDown, onBlur,
onCommit, onCancel and the value/initial logic accordingly.
- Around line 446-512: The effect currently depends on overInfo causing
listeners to be removed/re-added on every hover update and onUp reads a stale
closure value; fix by making the handlers stable and reading live state via
refs: remove overInfo from the effect dependency list, create an overInfoRef
that you update whenever you call setOverInfo, and inside the effect define
onMove and onUp to read/write overInfoRef.current (and use
dragRef/containerRef/controller as needed) so the global pointermove/pointerup
listeners are added once and onUp uses the latest hit value; keep controller in
deps only if it can change or otherwise capture it via a ref too.

In `@editor/app/`(dev)/ui/components/tree-view/_row.tsx:
- Around line 129-132: The left-pointer onPointerDown handler (the onPointerDown
that calls onDragStart?.(row.id, e)) is firing even when clicking the chevron;
add a guard that detects if the event target is inside the chevron element and
return early so we don't arm drag. Concretely: mark the chevron DOM node with a
stable identifier (e.g. data-chevron or class "chevron") and update the
onPointerDown (and the similar pointer handlers around lines 163-169) to check
if (e.target instanceof HTMLElement && e.target.closest('[data-chevron],
.chevron')) return; before calling onDragStart/onPointer handlers; keep using
row.id and onDragStart so the rest of behavior is unchanged.

In `@editor/app/`(dev)/ui/components/tree-view/_themes.tsx:
- Around line 97-104: selectionSubtree can throw when controller.getSelection()
contains node ids that were removed because source.getNode(id) may return
undefined or throw; update selectionSubtree to first guard/filter selection ids
against the source (e.g., use a safe check like source.hasNode(id) or check that
source.getNode(id) exists before accessing .meta) before calling isContainerKind
and building containerAnchors, and ensure any access to source.getNode(id).meta
is null-checked to avoid crashes during render in the selectionSubtree function
and related uses of sel/containerAnchors.

In `@editor/app/`(tools)/(packages)/packages/[%40grida]/tree-view/page.tsx:
- Around line 64-75: The two Link components rendering external links (the ones
using NPM_URL and GITHUB_URL in page.tsx that include target="_blank") should
add rel="noopener noreferrer" to avoid exposing window.opener; update the Link
props for the NPM and GitHub links (the Link elements wrapping the
Button/NpmLogoIcon and Button/GithubIcon) to include rel="noopener noreferrer"
alongside target="_blank".

In `@packages/grida-tree-view/__tests__/_helpers.ts`:
- Around line 39-45: The buildLinear helper currently always pushes a root node
with children ["n0"] which leaves a dangling reference when depth === 0; update
buildLinear to handle depth=0 by making the root's children an empty array in
that case (i.e., conditionally set the root node's children to [] when depth ===
0), and ensure the loop that pushes nodes for `n${i}` still only runs when depth
> 0 so no `n0` is referenced without being created.

In `@packages/grida-tree-view/__tests__/into-nearest-ancestor.test.ts`:
- Around line 5-8: The helper isFolder has been passed to intoNearestAncestor
with unsafe "as never" casts that disable type checking; replace those casts by
giving isFolder the exact predicate signature expected by intoNearestAncestor
(match parameter types and return boolean) or create a properly typed wrapper
that adapts it—e.g., ensure the function signature uses the same TreeSource and
NodeId types (or a constrained generic like (source: TreeSource<any>, id:
NodeId) => boolean) so calls to intoNearestAncestor use isFolder without any "as
never" assertion and retain full type safety.

In `@packages/grida-tree-view/README.md`:
- Line 189: Fix the wording typo in the README table row for "Selection" /
"SelectionAdapter": change the phrase "standalone uses get a default" to
"standalone users get a default" so the row reads "Editors with existing
selection plug in; standalone users get a default." Locate the table entry
mentioning Selection and SelectionAdapter and update that cell text accordingly.
- Line 25: Update the inconsistent test-count phrasing in the README by choosing
a single, accurate statement (either a specific number or a non-numeric phrase
like "≈90 unit tests" or "dozens of unit tests") and apply it to both
occurrences: the sentence beginning "Tested at the unit level. ~90
Node-environment tests..." and the later lines that currently state "~80 tests";
ensure both phrases match exactly and reflect the current test suite.

In `@packages/grida-tree-view/src/constraints.ts`:
- Around line 50-57: The not function returns a new MoveConstraint but currently
drops c.resolveDropPosition contrary to its docstring; update not (the exported
function not that takes MoveConstraint c) to return an object that keeps the
negated canMove and also forwards resolveDropPosition (e.g. include
resolveDropPosition: c.resolveDropPosition if present) so wrapped constraints
that rely on coercion still work; ensure you reference c.resolveDropPosition and
c.canMove when constructing the returned MoveConstraint.

In `@packages/grida-tree-view/src/controller.ts`:
- Around line 88-95: When the underlying source emits changes (see the
subscription callbacks created in the blocks containing this._unsubscribeSource
= this.source.subscribe(...) and the other occurrences around the ranges noted),
stale IDs can remain in _focused and in the selection adapter so later calls to
source.getNode(...) throw; update those subscription handlers to normalize state
after invalidating rows: iterate over _focused and the selectionAdapter's ids
and remove or clear any id for which source.getNode(id) (or a source.has/id
existence check) returns falsy, then emit the appropriate events (e.g., "rows"
and "selection") so the UI sees the cleaned state. Ensure this logic is added to
the three subscription locations referenced (around the existing calls to
this._rows.invalidate(), this.emit("rows"), and the other source subscription
blocks).

In `@packages/grida-tree-view/src/drag.ts`:
- Around line 72-80: resolveDropPosition currently treats placement === "into"
as valid for any target row which can produce a parent that isn't a container;
update resolveDropPosition to verify the over node can accept children before
returning the "into" result: check the overNode (e.g., overNode.isContainer or
another appropriate property/method that indicates it can have children) and
only allow the "into" branch when that check passes, otherwise fall back to a
different placement (e.g., "after"/"before") or return null/invalid. Ensure you
reference and use the existing symbols over, overNode, placement, and itemSet in
the function so the filtered children logic stays intact but only runs when the
overNode is a valid container.

In `@packages/grida-tree-view/src/keymap.ts`:
- Around line 95-99: The bare-key fallback in lookupAction incorrectly uses
event.key directly and bypasses normalizeKey; change the fallback to
normalizeKey(event.key) (or call keyComboOf with only the key) so that bare-key
bindings like space (" " vs "Space") are normalized before lookup — update the
branch that currently returns keymap[event.key] to use normalizeKey(event.key)
(or keyComboOf(event) variants) and keep the initial combo check using
keyComboOf and keymap as-is.

In `@packages/grida-tree-view/src/source.ts`:
- Around line 117-125: The remove(id: NodeId) method currently only deletes the
single node but leaves its descendants in _nodes; change remove to collect the
full subtree (e.g., using a stack/queue starting from id, repeatedly pushing
each node's children from getNode(nodeId)) and then remove every collected id
from this._nodes, also update the parent's children array (as current code does)
and finally call this.bump(); ensure you handle the case when node or
node.parent is missing before mutating.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@packages/grida-tree-view/src/keymap.ts`:
- Around line 50-51: The key matching fails because single-letter keys aren't
case-normalized: update normalizeKey (used by keyComboOf) to convert
single-character alphabetical keys to uppercase so that events with
event.key="a" map to the keymap entries like "Mod+A"; specifically, detect when
the normalized key is a single ASCII letter and call .toUpperCase() (preserving
existing modifier normalization logic) so keyComboOf produces "Mod+A" and
matches the keymap entry "Mod+A".

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@editor/app/`(dev)/ui/components/tree-view/_showcase.tsx:
- Around line 239-249: The stage loses keyboard focus after clicking shapes
because clicking only updates tree selection; update the pick/selection handler
inside SvgStage (the code that responds to mouse picks and calls
controller.select / selection updates) to also set focus to the stage container
element (ensure the stage root has a tabbable attribute like tabIndex if not
already) and call .focus() after selecting a shape so Delete/Backspace shortcuts
bound on the stage container will work immediately; apply the same change to the
other mouse-pick handlers referenced in the same file (the other pick handlers
around lines 273–319).

In `@editor/app/`(dev)/ui/components/tree-view/_themes.tsx:
- Around line 988-1000: The button currently only stops propagation on click, so
pointerdown still bubbles and can start a row drag; add an onPointerDown handler
to the same button element (the one with type="button" and onClick that calls
e.stopPropagation()) that calls e.stopPropagation() (and optionally
e.preventDefault() if you want to prevent focus/drag-start) to prevent the
pointerdown from bubbling into the row drag logic; update both flag buttons (the
visibility/lock buttons rendered by this component) so their onPointerDown
blocks propagation.

In `@editor/app/`(tools)/(packages)/packages/[%40grida]/tree-view/page.tsx:
- Line 27: The code references the React namespace type React.ComponentType
(used around the component typings at React.ComponentType) but doesn't import
React, which will fail under the modern JSX transform; add an explicit type-only
import such as import type React from "react" (or import React from "react") at
the top of the file so React.ComponentType is resolved, then rerun TypeScript
checks to confirm the type error is fixed.

In `@editor/components/ui-editor/tree.tsx`:
- Around line 137-152: Replace the interactive <span> used for the chevron with
a semantic <button type="button"> element to restore keyboard and assistive-tech
accessibility: keep the data-slot="tree-item-chevron", className, the
onPointerDown handler (e.stopPropagation()), and the existing onClick behavior
that calls onChevronClick, add an appropriate aria-label (e.g.,
aria-label="Toggle folder" or similar) and ensure the ChevronDownIcon remains
the child; update any CSS expectations if necessary but do not change the
onChevronClick function or folder conditional logic.

In
`@editor/grida-canvas-react-starter-kit/starterkit-hierarchy/node-hierarchy-tree-item.tsx`:
- Around line 156-157: The action buttons (lock/visibility) currently only stop
click propagation so the row-level onPointerDown still arms row drag; update the
button handlers to also stop pointerdown propagation by adding an onPointerDown
handler that calls e.stopPropagation() alongside the existing onClick handler on
each action button (the same change should be applied to the other action
buttons in the block around where onClick/onPointerDown are used, e.g., the
second group at lines ~213-231), ensuring the row-level onPointerDown (row
drag/select) does not receive the pointerdown from those buttons.

In `@editor/grida-canvas-react-starter-kit/starterkit-hierarchy/tree-node.tsx`:
- Around line 568-607: The drag lifecycle isn’t gated to the originating pointer
so a different pointer can drive onMove/onUp; fix by recording the initiating
pointerId (use pendingRef.current.pointerId or store activePointerId when
starting drag in onMove) and early-return in onMove and onUp unless e.pointerId
(or the eventless up handler should accept a pointerId param or check the stored
active id source) matches that stored id; apply the same pointerId gating logic
for the other handlers referenced around lines 612–620 (same use of pendingRef,
dragRef, controller.startDrag, applyHit, commitDrag) so only the initiating
pointer can move/commit the drag.
- Around line 76-79: The comment above the TREE_INDENT constant contains a
CI-failing typo "mis-resolve"; update that word to a recognized term (for
example "mishandle" or "mis-handle") in the comment near the TREE_INDENT
declaration so the typo check passes while keeping the original meaning; locate
the comment that references `<Tree indent>` and the horizontal pop-out geometry
in tree-node.tsx and replace "mis-resolve" with the chosen correct word.

In `@editor/grida-canvas-react-starter-kit/starterkit-hierarchy/tree-scene.tsx`:
- Around line 284-299: The pointercancel path must not reuse the pointerup logic
because a cancelled pointer should abort the drag instead of committing it;
change the listeners so pointerup calls the existing onUp (which does
controller.commitDrag(), clears dragRef, pendingRef, and setDrop) but
pointercancel calls a new onCancel handler that only clears dragRef.current,
pendingRef.current, and calls setDrop(null) (or calls a dedicated
controller.cancelDrag() if such exists) without invoking controller.commitDrag;
update the addEventListener/removeEventListener calls to register onCancel for
"pointercancel" and leave "pointermove" and "pointerup" using onMove and onUp
respectively.

In `@editor/grida-canvas-react-starter-kit/starterkit-hierarchy/tree-source.ts`:
- Around line 48-53: refresh() currently always calls this._snapshot(),
increments this._version and notifies this._listeners even if the node map did
not change; change refresh() to only increment _version and call listeners when
the snapshot actually changed — either make _snapshot() return a boolean/changed
flag or have refresh capture the previous node map (or a stable fingerprint) and
compare it to the new one before bumping this._version and notifying
this._listeners; update any callers accordingly (methods referenced: refresh(),
_snapshot(), _version, _listeners).

In `@packages/grida-tree-view/FEEDBACKS.md`:
- Around line 512-519: The fenced code block shown (starting at the block that
begins with "source: <root>[a,b,c]; a:[a1,a2]   flatten.reverseChildren: true")
is missing a language tag which triggers MD040; add a language identifier (for
example `text` or `ts`) immediately after the opening triple backticks (e.g.,
change ``` to ```text) so the block is recognized correctly by the linter.

---

Duplicate comments:
In `@packages/grida-tree-view/src/drag.ts`:
- Around line 93-101: resolveDropPosition currently returns an "into"
destination for dir === "into" without verifying the target can contain
children; update the branch in resolveDropPosition to call
source.isContainer(over) (or similar API used for container checks) and if it
returns false, reject the "into" drop (e.g., return null or fall back to a
non-"into" placement) instead of returning an invalid into target; adjust the
code around overNode, filtered, and the return object so the into case only
executes when source.isContainer(over) is true.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Duplicate comments:
In `@editor/app/`(dev)/ui/components/tree-view/_fixtures.ts:
- Around line 1108-1149: Validate and guard against non-positive depth or
non-positive groups before building chain nodes: in the code that reads opts
(groups, depth) and constructs chainIds, add an early check (e.g., if (groups <=
0) return or normalize groups; if (depth <= 0) handle as depth = 1 or build
group nodes with no chain) so you never rely on chainIds[0] or
chainIds[chainIds.length - 1] with non-null assertions; update the logic around
variables chainIds, nodes.push(...) that reference chainIds[0] and
chainIds[chainIds.length - 1] (and the expanded array population) to either skip
chain construction when depth <= 0 or to produce a single leaf id safely without
using the ! operator.

In `@editor/app/`(dev)/ui/components/tree-view/_showcase.tsx:
- Around line 468-471: The onPick handler focuses the node but not the stage
container, so keyboard handlers bound to the stage (onKeyDown) don’t receive
focus after a click; update onPick to programmatically focus the stage container
before selecting the node (e.g. call your stage ref’s focus method or a
controller.focusStage() helper) and then call controller.focus(id) and
controller.select([id], modeFromEvent(e)) so Delete/Backspace works immediately;
adjust the same change for the other onPick occurrence (lines 486-493).

In `@editor/app/`(dev)/ui/components/tree-view/_themes.tsx:
- Around line 998-1003: In the RowFlagButton component the button only stops
propagation on click, which is too late for drag-starts; add an onPointerDown
handler to the same <button> (e.g., onPointerDown={(e) => e.stopPropagation()})
so pointerdown events are stopped immediately and prevent accidental row
drags—keep the existing onClick handler intact.